feat: SFPG cross-rank completion — capabilities, ZBL bridging and spin+ZBL multi-rank - #5939

…ties

Six capabilities with concrete defaults on BaseAtomicModel, descriptor
delegation on DPAtomicModel, and any/all aggregation on
LinearEnergyAtomicModel (issue deepmodeling#5906 Task 4).

LinearEnergyModel compositions need it once the with-comm gate opens for
them (issue deepmodeling#5906 Task 4); one owner, next to the non-comm twin.
_translate_energy_keys moves along (make_model cannot import from
ener_model without a cycle); importers re-pointed.

_needs_with_comm_artifact / compact-edge-pairs / edge-dtype /
graph-export answer via the atomic model; two-DPA2 linear compositions
now get their with-comm artifact (issue deepmodeling#5906 Task 4).

.pt-checkpoint eval and enable_compile no longer reach for a single
descriptor; get_standard_model honors bridging_method like its dpmodel
twin, with _compose_bridging as the one composition owner (issue deepmodeling#5906
Task 4 audit findings).

R = B^T as linear maps over node rows, so the reverse-accumulate's
vector-Jacobian product is the forward broadcast (issue deepmodeling#5906: gate
gradients cross ranks).

compute_edge_src_gate packs (N,2) [log_eta, zero_count] through the
optional node_partial_exchange hook; zero_count becomes float so both
partials ride one border exchange. dpmodel's _gate_partial_exchange
raises (single-process reference); pt_expt overrides it (issue deepmodeling#5906).

_gate_partial_exchange = reverse-accumulate (border_op_backward) then
forward-broadcast (border_op) of the (N,2) [log_eta, zero_count]
partials. Eager self-comm parity vs the folded reference at 1e-12 with
a cross-boundary close pair in both bridging channels (hard-freeze and
transition zone); identity-exchange ablation diverges (issue deepmodeling#5906).

supports_edge_parallel flips to True (the SFPG exchange completes the
gate partials across ranks); the graph freeze embeds the nested
forward_lower_with_comm.pt2 for bridged compositions and gen_dpa4_zbl
asserts it (issue deepmodeling#5906 Task 2).

Closes the deepmodeling#5906 pt gap: the gate's per-node partials are completed via
border_op_backward + border_op before the gate is applied, and the
model-level ZBL injection reads EXTENDED types (the parallel path used
to crash on ghost src indices). Bridged SeZM reports
supports_edge_parallel=True; close-pair parity pinned on both bridging
channels with an identity-exchange ablation.

Replaces the fails-fast test: the with-comm artifact now completes the
SFPG partials across ranks, so a 2-rank run with the 0.9 A pair
straddling the processors 2 1 1 boundary must (and does) match the
1-rank reference (issue deepmodeling#5906 Task 2 E2E).

…ling#5906 Task 3)

The spin wrapper needed NO production change: the gate exchange sits
below it. gen_dpa4_spin_zbl asserts the with-comm artifact; python
self-comm parity (energy/force/force_mag, both bridging channels) at
1e-12; first-ever LAMMPS file for the spin+ZBL variant, incl. 2-rank
close-pair parity via pair_style deepspin.

Empty-rank behavior (zbl fail-fast twin; first test of the DeepSpin
phantom path -- owned-empty ranks with ghosts phantom-pad and match),
charge_spin via pair_deepspin, and dp-freeze default-CLI resolution for
zbl and native-spin compositions (issue deepmodeling#5906 Task 12b).

The SFPG per-node partials are completed across ranks by one
reverse-accumulate + forward-broadcast border exchange of an (N,2)
tensor per forward pass (issue deepmodeling#5906); also sweeps the stale
pre-deepmodeling#5884 native-spin single-rank claims.

…fpg-multirank

CodeRabbit review on deepmodeling#5939.

Two executable assertions still pinned the pre-deepmodeling#5906 single-rank
contract (`has_comm_artifact is False`) for the ZBL and native-spin+ZBL
graph freezes. They are skipped only when CI=true, so a local full-suite
run compiled the archive and then failed on the obsolete expectation.
Flip both to the multi-rank contract and also assert the nested
forward_lower_with_comm.pt2 entry is present.

make_model() produces DOS, dipole, polar, property and energy models, but
forward_lower_graph_exportable_with_comm hard-codes do_grad_r("energy"),
do_grad_c("energy") and _translate_energy_keys. Defining it on the common
factory made every non-energy model advertise an API that would raise on
the missing energy output; the serializer's energy gate only hid it.

Give it the same ownership as its non-comm twin: define it on EnergyModel
and alias it in LinearEnergyModel. NativeSpinEnergyModel is built on
EnergyModel, so the spin route keeps it through the MRO.

Six sites still described the pre-deepmodeling#5906 contract or a CLI behaviour that
does not exist:

- dpa4.uses_graph_lower / sezm.has_message_passing_across_ranks claimed
  bridging still fails multi-rank fast, contradicting the capability
  split this branch introduces.
- NativeSpinModelKind cited "native-spin lowers are single-rank only" as
  its motivating example; only the DENSE lower is excluded now.
- get_sezm_model advertised bridging and spin as unsupported although the
  factory deliberately constructs both; replace with the precise matrix
  (deepspin scheme, lora, use_compile, preset_out_bias remain unsupported).
- doc/model/dpa4.md offered plain DPA4 a choice of dense or graph freeze
  via a '--lower-kind auto' default. There is no 'auto' choice (nlist and
  graph only, default nlist) and freeze() overrides any non-graph request
  to graph for graph-capable models.
- gen_dpa4_spin_zbl.py still headed its contract 'Single-rank only'.

Conflict in deepmd/pt_expt/utils/serialization.py: upstream deepmodeling#5913
relocated the graph edge-dtype helper to deepmd/pt_expt/model/graph_lower.py
as a public graph_edge_dtype(), while this branch had rewritten the same
helper in place to answer from the atomic-model capability instead of
reaching through a single .descriptor.

Resolution keeps BOTH: upstream's location (serialization.py imports it
from graph_lower) with this branch's implementation. The reach-in version
is wrong for compositions -- a LinearEnergyAtomicModel has no .descriptor,
so a bridged/ZBL model would silently report float64 regardless of its
children -- which is exactly what the capability aggregation fixes.
Dropped the now-unused torch import from graph_lower.py.

test_lammps_dpa4_spin_zbl_pt2.py shared 421 byte-identical lines with
test_lammps_dpa4_spin_graph_pt2.py: the 4-atom NiO system, the live DeepPot
reference, setup/teardown, LAMMPS construction, force_mag gathering, the
MPI subprocess/parser and the parity assertions. Any change to tolerances,
the runner output schema or timeout handling had to be made twice.

Extract them into dpa4_spin_harness.py. Each module now carries only its
archive, its geometry and its variant-specific claims:

  spin_graph  605 -> 230 lines
  spin_zbl    566 -> 214 lines

Kept narrowly scoped rather than folded into lammps_test_utils: these
pieces are DPA4-native-spin-specific (`atom_modify map yes` for the graph
route's atom map, the spin_norm/hbar `fm` convention, and a timeout-bounded
runner that SIGKILLs the whole mpirun process group), and moving them into
the shared module would change behaviour for unrelated tests.

Same 8 tests collect with the same IDs; the graph module's two MPI tests
now use the shared assertion helper the ZBL module had already factored
out. Runtime validation is the C++/LAMMPS CI jobs: the .pt2 fixtures are
not present locally and this box has no reliable MPI.